package com.jt.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.jt.mapper.ItemCatMapper;
import com.jt.pojo.ItemCat;
import com.jt.service.ItemCatService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.*;

@Service
public class ItemCatServiceImpl implements ItemCatService {
    @Autowired
    private ItemCatMapper itemCatMapper;


    /**
     * 优化商品列表
     * 				Map<0，所有的一级菜单>
     * 				Map<一级id，当前一级下的二级菜单>
     * 				Map<二级id，当前二级下的三级菜单>
     * 思路：
     *      1.判断Map集合中是否存在key
     *      2.如果key不存在，准备一个新的list集合，将自己作为第一个元素添加
     *      3.如果key存在，获取list集合，将自己追加进去。
     * */

    public Map<Integer,List<ItemCat>> getMap(){
        //2.对Map集合初始化
        Map<Integer,List<ItemCat>> map = new HashMap<>();
        //1.查询数据库的所有记录
        List<ItemCat> list = itemCatMapper.selectList(null);
        //3.
        for (ItemCat itemCat : list){
            int key = itemCat.getParentId();
            //判断key是否存在
            if(map.containsKey(key)){//true有数据
                map.get(key).add(itemCat);//获取key，存入集合
            }else{//false 无数据
                List<ItemCat> childrenList = new ArrayList<>();
                childrenList.add(itemCat);//存入list集合
                map.put(key,childrenList);//存入map集合
            }
        }
        return map;
    }
    /**
     * level 1/2/3
     * */
    @Override
    public List<ItemCat> findItemCatList(Integer level) {
        long startTime = System.currentTimeMillis();
        //1.获取数据信息
        Map<Integer,List<ItemCat>> map = getMap();
        //2只获取一级菜单
        if (level == 1) return map.get(0);
        //3获取当前1级和2级菜单
        if (level == 2) return getTwoList(map);
        //4获取当前2级和3级菜单
        List<ItemCat> list = getThreeList(map);
        long endTime = System.currentTimeMillis();
        System.out.println("耗时："+(endTime-startTime)+"毫秒");
        return list;
    }

    private List<ItemCat> getTwoList(Map<Integer, List<ItemCat>> map) {
        List<ItemCat> oneList = map.get(0);
        for (ItemCat oneItemCat : oneList){
            int key = oneItemCat.getId();   //一级的id是二级的父级id
            List<ItemCat> twoList = map.get(key);
            oneItemCat.setChildren(twoList);
        }
        //由一级携带二级返回
        return oneList;
    }

    private List<ItemCat> getThreeList(Map<Integer, List<ItemCat>> map) {
        //1.获取一级和二级数据
        List<ItemCat> oneList = getTwoList(map);
        for (ItemCat oneItemCat :oneList){
            List<ItemCat> twoList = oneItemCat.getChildren();//二级集合
            if (twoList == null){ //说明该一级下无二级数据，直接跳过本次循环
                continue;
            }
            for (ItemCat twoItemCat : twoList){
                int key = twoItemCat.getId();//二级的id是三级的父级id
                List<ItemCat> threeList = map.get(key);
                twoItemCat.setChildren(threeList);
            }
        }
        //由一级携带二级和三级返回
        return oneList;
    }

    /**
     * 修改商品状态
     * */
    @Override
    public void updateStatus(ItemCat itemCat) {
        itemCat.setUpdated(new Date());
        itemCatMapper.updateById(itemCat);
    }

    /**
     * 商品新增
     * 有些数据应该提前填充 status/创建时间/修改时间
     * */
    @Override
    @Transactional //新增加事务注解（增删改查）
    public void saveItemCat(ItemCat itemCat) {
        itemCat.setStatus(true);
//                .setCreated(new Date())
//                .setUpdated(itemCat.getCreated());
        itemCatMapper.insert(itemCat);
    }
    /**
     * 商品分类修改
     * */
    @Override
    @Transactional
    public void updateItemCat(ItemCat itemCat) {
        itemCat.setUpdated(new Date());
        itemCatMapper.updateById(itemCat);
    }
    /**
     * 商品删除
     * 删除思路
     *      1.判断是否为3级   如果是，直接删除
     *      2.判断是否为2级   如果是，先删除3级，再删除2级
     *      3.如果是1级，先查询2级，再删除3级，再删除2级，再删除1级
     * */
    @Override
    @Transactional
    public void deleteItemCat(ItemCat itemCat) {
        if(itemCat.getLevel() == 3){
            itemCatMapper.deleteById(itemCat.getId());
            return;
        }
        if (itemCat.getLevel() == 2) {
            int twoId = itemCat.getId();
            QueryWrapper<ItemCat> queryWrapper = new QueryWrapper<>();
            queryWrapper.eq("parent_id", twoId);
            //删除3级数据
            itemCatMapper.delete(queryWrapper);
            itemCatMapper.deleteById(twoId);
            return;
        }
        //1.先查询二级id
        int oneId = itemCat.getId();
        QueryWrapper<ItemCat> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("parent_id", oneId);
        List twoIdList = itemCatMapper.selectObjs(queryWrapper);
        if (twoIdList.size() == 0){
            //如果一级没有二级数据则直接删除一级数据
            itemCatMapper.deleteById(oneId);
        }else{//else表示有二级,可以删除三级
            queryWrapper.clear();
            queryWrapper.in("parent_id", twoIdList)//先删三级数据
                    .or()
                    .in("parent_id", oneId)//再删二级数据
                    .or()
                    .eq("id", oneId);//再删一级数据
            itemCatMapper.delete(queryWrapper);
        }
    }

    /**
     * 只查询一级菜单  parent_id = 0 或者level=1
     * 查询二级菜单   parent_id = 一级id
     * 从数据库拿数据，每次循环都查数据库
     * *//*
    @Override
    public List<ItemCat> findItemCatList(Integer level) {
        long startTime = System.currentTimeMillis();
        QueryWrapper<ItemCat> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("parent_id", 0);
        List<ItemCat> oneList = itemCatMapper.selectList(queryWrapper);
        //遍历一级集合进行二级菜单查询
        for (ItemCat oneItemCat : oneList){
            //获取一级对象的ID
            int oneId = oneItemCat.getId();
            //清空多余的条件
            queryWrapper.clear();
            //查询二级数据
            queryWrapper.eq("parent_id", oneId);
            List<ItemCat> twoList = itemCatMapper.selectList(queryWrapper);
            for (ItemCat twoItemCat : twoList){
                //获取二级对象的ID
                int twoId = twoItemCat.getId();
                //清空多余的条件
                queryWrapper.clear();
                //查询二级数据
                queryWrapper.eq("parent_id", twoId);
                List<ItemCat> threeList = itemCatMapper.selectList(queryWrapper);
                //将三级封装到二级中
                twoItemCat.setChildren(threeList);
            }
            //将二级封装到一级中
            oneItemCat.setChildren(twoList);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("耗时:"+(endTime-startTime)+"毫秒");
        return oneList;
    }*/
}
